import org.junit.Test;

import java.util.Arrays;

/**
 * 程序只有一個入口：main方法
 * 理解：類中只有一個主方法
 *
 * 類中多個類似主方法：單元測試 Junit1.4【外置jar包】
 *                  jar 別人寫好的類，直接使用
 * 單元測試：專門測試功能模塊
 * 單元測試步驟：
 * 1.編寫注解  @Test 編寫單元測試
 * 2.編寫方法  修飾符 返回值 方法名(){}
 */

public class 基礎語法 {
    /**
     * float 單精度 不常用 4字節 取小數點后6位有效數
     * 寫法：float 標識符=字面量F/l;
     */
    @Test
    public void basic() {
        float pi = 3.1415926535F;
        System.out.println(pi); //3.
        int a = 128 + 256;  //00000000 00000000 00000001 10000000
        byte b = (byte) a;  //砍掉前24位 剩餘部分 10000000
        System.out.println(b); // -128
        //       int _123F=1;
        //        int  123F=1;
        //       int  if  =1;
        String name = "曲梓朔";
        int age = 18;
        System.out.println(name + age);
    }

    /**
     * 数组  Array  引用类型  对象：通过new创建
     * 数组相当于一堆相同"数据"集合
     * 单元测试1：testArray  创建数组方式以及初始化
     */
    @Test
    public void testArray() {
        //创建arr空数组，长度4
        int[] arr = new int[4];        //动态初始化：指定空间，并且按照空间分元素
        int[] arr1 = {1, 2, 3};          //静态初始化：直接给定值
        int arr2[] = new int[4];       //动态初始化：指定空间，并且按照空间分元素
        int[] arr3 = new int[]{1, 2, 3}; //动态初始化：指定空间，并且按照空间分元素
        //从arr1静态初始化数组获取 2 元素  数组名[下标：0开始]
        System.out.println(arr1[1]); //输出 2 元素值
        //从arr1静态初始化数组获取  长度
        System.out.println(arr1.length);
        //从arr1中获取下标为4的值  输出？  数组下标越界异常
        //System.out.println(arr1[4]); //ArrayIndexOutOfBoundsException: 4
        //空间长度没有超出范围，数据类型：基础数据类型
        //                      int:默认值  0
        //                    float:默认值  0.0
        //                     char:默认值  特殊符号
        //                  Boolean:默认值  false
        int[] arr4 = new int[4]; //动态初始化：指定空间，并且按照空间分元素
        System.out.println(arr4[1]);
        float[] arr5 = new float[4];
        System.out.println(arr5[1]);
        char[] arr6 = new char[4];
        System.out.println(arr6[1]);
        boolean[] arr7 = new boolean[4];
        System.out.println(arr7[1]);

    }

    /**
     * 数据遍历【3种迭代方式】
     * 1.普通for jdk1.5之前使用
     * 2.增强for jdk1.5之后使用  推荐
     * 3.工具类  推荐
     */
    @Test
    public void testIterate() {
        int[] arr = {1, 2, 3, 4}; //静态数组
//         for (int i=0;i< arr.length;i++){  //获取数组下标
//             System.out.println(arr[i]);
//         }
//         遍历数据类型    引用名：数组名
//           for(int i:arr){  //直接打印元素值
//               System.out.println(i);
//           }
        //工具类   toString方法 打印所有数组元素
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 数组的扩容
     * Java数组对象大小是固定的，数组对象不可以扩展的
     * 使用数据扩容方式变通
     * Arrays.copyOf 方法创建数组副本
     */
    @Test
    public void testCopy() {
        char[] arr = {'唐', '山'}; //定义数组，长度固定：2个
        //使用Arrays提供copyOf方法创建当前数组的副本
        char[] temp = Arrays.copyOf(arr, 4);
        //副本 赋值给 不可改变数组
        char[] tarr = temp;
        System.out.println(tarr);  //唐  山  \u0000  \u0000
        tarr[2] = '工';
        tarr[3] = '业';
        System.out.println(tarr);
    }

    /**
     * 拓展：数组输出，根据数据类型不同，输出效果不同【看】
     * 数组语法：
     * 数据类型[] 数组名=new 数据类型[];
     * 数据类型：基础数据类型+引用类型
     * 创建数据根据数据类型：明确是什么类型
     */
    @Test
    public void testLook() {
        //字符数组
        char[] china = {'中', '国'};
        System.out.println(china);  //输出：中国
        //JavaOOP面向对象知识点：数组输出方法提供重载功能，字符数组，优化为字符串

        //常规数组输出效果 Arrays工具类 toString方法：打印数组
        System.out.println(Arrays.toString(china));

        //数值数值
        int[] i = {1, 2};
        System.out.println(i);  //"[ 数组" "I类型” @“3d82c5f3”
        //查看数组实际效果
        System.out.println(Arrays.toString(i));
    }

    /**
     * 数组经典案例：
     * int[] arr={3,6,4,1}
     * 数组元素排序：升序，降序
     * 面试题：上述数组按照升序方式排序
     * 解题思路三种方案：选择排序、冒泡排序、插入排序
     * 冒泡排序：双层for循环使用，比较相邻的元素，将元素小的值放到前面
     */
    @Test
    public void bubbleSort() {
        int[] arr = {3, 6, 4, 1};  //静态数组
        // for 外层循环【轮】+ for 内层循环【次】
        // 考虑：每一轮需要比较几次

        //重点
        for (int i = 0; i < arr.length - 1; i++) {  //外层for:控制比较轮
            for (int j = 0; j < arr.length - 1 - i; j++) {  //内层for：两两比较
                //交换：第一个值>第二个值  成立  交换  升序：从小到大
                if (arr[j] > arr[j + 1]) {
                    //交换：第三方数组变量  交换数组名temp
                        int temp = arr[j];  //①从第一个值交给第三方数组变量
                        arr[j] = arr[j + 1];//②第二个值交给第一个值
                        arr[j + 1] = temp;  //③第三方变量交给第二个值
                }
            }

        }
        System.out.println(Arrays.toString(arr));
    }

    @Test
    public void sort(){
        int[] arr={3,6,4,1};
        //工具类：提供sort()排序方法
        Arrays.sort(arr);  //默认：升序
        System.out.println(Arrays.toString(arr));

  }
}

